package ch.penas.business.service;

import java.io.Serializable;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.persistence.Query;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;

import junit.framework.Assert;
import ch.penas.business.dom.RechercheUtilisateur;
import ch.penas.business.dom.Utilisateur;

/** @author Daniel */
public class UtilisateurServiceImpl extends UtilisateurAbstractMYSQL implements UtilisateurService, Serializable {

    /** Serialisation de la class pour une question de securiter. */
    private static final long serialVersionUID = -6797092500849314538L;

    /** Le nom de la liste ou ce trouve les utilisateur. */
	private List<Utilisateur> mUtilisateurList;

	/** Le nom de la liste ou ce trouve les utilisateur rechercher. */
	 private List<Utilisateur> mRechercheUtilisateurList = new ArrayList<Utilisateur>();
	
	/** Permet de stocker un utilisateur rechercher le temps de l'ajouter dans la list des utilisateur rechercher. */
	private Utilisateur tempsRechercheUtilisateur;
	
    /** Constructeur de la class UtilisateurServiceImpl. */
	public UtilisateurServiceImpl() {		
		this.mUtilisateurList = new ArrayList<Utilisateur>();
		this.mRechercheUtilisateurList = new ArrayList<Utilisateur>();
	}
	
    /** Permet de recupere la valeur de la liste ou ce trouve les utilisateurs.
     * 
     * @return mUtilisateurList
     */
	public final List<Utilisateur> getAll() {
		return this.mUtilisateurList;
	}
	
    /** Permet d'ajouter un utilisateur a la base de donnée des utilisateur.
     * 
     * @param utilisateur est egale a un objet de la class Utilisateur
     */
	public final void add(final Utilisateur utilisateur) {
		try {
			initFixture();
			CriteriaBuilder qb = getEntityManager().getCriteriaBuilder();
			CriteriaQuery<Utilisateur> c = qb.createQuery(Utilisateur.class);
			Query query = getEntityManager().createQuery(c);

			int n = query.getResultList().size();

			getEntityTransaction().begin();
			getEntityManager().persist(utilisateur);
			getEntityTransaction().commit();

			Assert.assertEquals(n + 1, query.getResultList().size());

			closeEntityManager();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
    /** Permet de retourner le nombre d'utilisateur enregistrer dans la base de donnée.
     * 
     * @return resultQuery est egale a la list des utilisateur dans la base de donnée
     */
	public final int getNbUtilisateur() {
		Object resultQuery;
		try {
			initFixture();
		} catch (Exception e) {
			e.printStackTrace();
		}
			getEntityTransaction().begin();
			
			Query query = getEntityManager().createQuery("SELECT COUNT(e.nom) FROM Utilisateur e");
			int n = query.getResultList().size();

			resultQuery = query.getSingleResult();
			
			getEntityTransaction().commit();
			Assert.assertEquals(n, query.getResultList().size());
		
			try {
				closeEntityManager();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		return Integer.parseInt(resultQuery.toString());
	}
	
    /** Permet de rechercher si oui/non il existe un utilisateur dans la liste.
     * 
     * @param mRechercheUtilisateur est egale � la class RechercheUtilisateur
     */
	public final void search(final RechercheUtilisateur mRechercheUtilisateur) {
			if ((mRechercheUtilisateur.getSearchNom() != null) && (mRechercheUtilisateur.getSearchPrenom() != null) && (mRechercheUtilisateur.getSearchMail() != null)) {
				//if ((tempsRechercheUtilisateur.getNom().contains(mRechercheUtilisateur.getSearchNom())) && (tempsRechercheUtilisateur.getPrenom().contains(mRechercheUtilisateur.getSearchPrenom()))  && (tempsRechercheUtilisateur.getMail().contains(mRechercheUtilisateur.getSearchMail()))) {
					
					//System.out.println("Identifiant de l'utilisateur rechercher: " + mRechercheUtilisateur.getSearchNom() + " " + mRechercheUtilisateur.getSearchPrenom() + " Identifiant de l'utilisateur trouver: " + b.getNom() + " " + b.getPrenom());
				try {
					initFixture();
				} catch (Exception e) {
					e.printStackTrace();
				}
					getEntityTransaction().begin();
					
					Query query = getEntityManager().createQuery("SELECT e FROM Utilisateur e WHERE e.nom='"+mRechercheUtilisateur.getSearchNom()+"'", Utilisateur.class);
					int n = query.getResultList().size();

					List<Utilisateur> b = query.getResultList();
					for (Utilisateur a : b){
					System.out.println("nom=============================="+a.getNom());
					this.tempsRechercheUtilisateur = a;
					this.addRecherche(this.getTempsRechercheUtilisateur());
					}
					
					getEntityTransaction().commit();
					Assert.assertEquals(n, query.getResultList().size());
				
					try {
						closeEntityManager();
					} catch (SQLException e) {
						e.printStackTrace();
					}
				
				
					//this.tempsRechercheUtilisateur = b;
					//this.addRecherche(this.getTempsRechercheUtilisateur());
				
				//} else {
					System.out.println("La recherche n'a pas aboutie !! " + mRechercheUtilisateur.getSearchNom() + " " + mRechercheUtilisateur.getSearchPrenom());
				//}
			} else {
				System.out.println("Erreur dans la recherche");
			}
		
	}

    /** Permet d'ajouter un utilisateur rechercher a la list des utilisateur.
     * 
     * @param sesultQuery2 est egale a un objet de la class utilisateur
     */
	public final void addRecherche(final Utilisateur sesultQuery2) {
		this.mRechercheUtilisateurList.add(sesultQuery2);
	}

    /** Permet de retourner un utilisateur rechercher.
     * 
     * @return tempsRechercheUtilisateur
     */
	public final Utilisateur getTempsRechercheUtilisateur() {
		return this.tempsRechercheUtilisateur;
	}
	
    /** Permet de recup�r� la valeur de la liste des utilisateur rechercher.
     * 
     * @return mRechercheUtilisateurList
     */
    public final List<Utilisateur> getAllRecherche() {
        return this.mRechercheUtilisateurList;
    }
}